sync-microservice/.gitignore (1)

139-140: Ensure dist placeholder exists for clean clones/builds

Good switch to ignore dist contents while tracking a placeholder. Make sure dist/README.md is actually committed; otherwise CI packaging that expects the directory may fail on clean checkouts.

#!/bin/bash
set -euo pipefail
for d in backend sync-microservice; do
  if [[ -f "$d/dist/README.md" ]]; then
    echo "OK: $d/dist/README.md present"
  else
    echo "MISSING: $d/dist/README.md" >&2
    exit 1
  fi
done

Prefer a neutral placeholder file name (e.g., .gitkeep) to avoid bundling docs unintentionally into installers.

frontend/src/constants/steps.ts (1)

2-2: Type-safety: mark STEPS as const

Exporting literal types helps prevent typos downstream.

-export const STEPS = {
+export const STEPS = {
   SERVER_CHECK: 'serverCheck',
   AVATAR_SELECTION_STEP: 'avatarSelection',
   FOLDER_SETUP_STEP: 'folderSetup',
   THEME_SELECTION_STEP: 'themeSelection',
   UPDATE_STEP: 'updates',
-};
+} as const;
+export type StepName = typeof STEPS[keyof typeof STEPS];

backend/.gitignore (1)

139-140: Mirror placeholder check for backend/dist

Same note as sync-microservice: verify dist/README.md is committed so packaging doesn’t break on a clean workspace.

#!/bin/bash
test -f backend/dist/README.md && echo "backend/dist/README.md OK" || { echo "Missing backend/dist/README.md"; exit 1; }

Consider using a .gitkeep instead of README if the file is only to keep the directory.

frontend/src-tauri/Cargo.toml (1)

3-3: Cargo.toml polish + compatibility check

• Typo in the comment (“definition s”).
• Confirm tauri = 2.3.1 actually requires/enables the "devtools" crate feature; in Tauri v2, devtools are usually toggled via tauri.conf.json.
• Versions: Rust tauri-plugin-process = "2.0.0" vs JS @tauri-apps/plugin-process ^2.3.0. Major aligns; please verify runtime compatibility.

-# See more keys and their definition  s at https://doc.rust-lang.org/cargo/reference/manifest.html
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

#!/bin/bash
set -euo pipefail
echo "Rust tauri version feature list:"
rg -nP '^tauri\s*=\s*\{[^}]*features\s*=\s*\[([^\]]*)\]' frontend/src-tauri/Cargo.toml -or '$1'
echo "Rust tauri-plugin-process:"
rg -n 'tauri-plugin-process' frontend/src-tauri/Cargo.toml
echo "JS plugin-process:"
jq -r '.dependencies["@tauri-apps/plugin-process"]' frontend/package.json
echo "Check devtools setting in tauri.conf.json:"
rg -n '"devtools"\s*:\s*(true|false)' frontend/src-tauri/tauri.conf.json || true

Also applies to: 8-8, 14-14, 23-23

frontend/package.json (1)

4-4: Version bump OK; verify plugin-process cross-compat

Major versions match Rust side (2.x). Please confirm the CLI and Rust/JS plugin versions are mutually compatible for your target OS matrix.

#!/bin/bash
set -euo pipefail
echo "CLI:"
jq -r '.devDependencies["@tauri-apps/cli"]' frontend/package.json
echo "JS plugin-process:"
jq -r '.dependencies["@tauri-apps/plugin-process"]' frontend/package.json
echo "Rust plugin-process:"
rg -n 'tauri-plugin-process\s*=\s*".*"' frontend/src-tauri/Cargo.toml

If compat is confirmed, consider using caret-less "2" on the Rust side for easier dependabot bumps to latest compatible minor.

Also applies to: 45-45

frontend/src-tauri/src/services/mod.rs (1)

966-966: Double-check tauri.conf.json mapping consistency

Ensure all resource mappings and any callers expecting “resources/server” are updated.

#!/bin/bash
set -euo pipefail
echo "Searching for old resource path references:"
rg -n 'resources/server' || true
echo "Confirm new mapping exists:"
rg -n '"resources/backend"' frontend/src-tauri/tauri.conf.json

Consider adding a parallel helper for "resources/sync-microservice" for symmetry with the new packaging.

frontend/src-tauri/capabilities/migrated.json (1)

79-79: Scope process permissions minimally

Adding "process:default" grants broad process access. Limit to only what the app needs (e.g., specific allow lists) to reduce attack surface.

#!/bin/bash
set -euo pipefail
echo "Ensure process plugin is actually initialized:"
rg -n 'tauri_plugin_process::init' frontend/src-tauri/src/main.rs || { echo "Missing tauri_plugin_process::init() in main.rs"; exit 1; }

backend/app/utils/microservice.py (2)

118-136: Optional: make dependency install idempotent/noisy-safe.

pip install -r on every start can be slow/noisy. Consider a marker file or hashing requirements.txt to skip when unchanged.

---

41-44: Optional: ensure logs are visible.

This module uses logging.getLogger(__name__) but the app switched to prints elsewhere. Either configure root logging in the backend on startup or switch these key messages to print for consistency.

frontend/src-tauri/src/main.rs (1)

28-28: Gate debug print to dev builds.

-            println!("Resource path: {:?}", resource_path);
+            #[cfg(debug_assertions)]
+            println!("Resource path: {:?}", resource_path);

backend/main.py (2)

69-93: Gate OpenAPI file generation to dev to avoid write failures in bundled apps.

-    try:
+    try:
+        if os.environ.get("GENERATE_OPENAPI", "0") != "1":
+            return

Usage: set GENERATE_OPENAPI=1 in dev to regenerate.

---

96-102: Consider restricting CORS in production.

allow_origins=["*"] is okay for local/Tauri, but consider a tighter policy (e.g., only tauri://localhost) when shipping.

frontend/src-tauri/tauri.conf.json (1)

56-58: DevTools enabled in config.

Fine for development; ensure release artifacts don’t ship with DevTools enabled if that’s undesired.

frontend/src/routes/AppRoutes.tsx (1)

10-10: Swap to lazy-load ComingSoon for lighter initial bundle

Optional: code-split ComingSoon since it’s used on multiple routes and not critical-path.

Apply:

-import { ComingSoon } from '@/pages/ComingSoon/ComingSoon';
+const ComingSoon = React.lazy(() => import('@/pages/ComingSoon/ComingSoon'));

And wrap these routes in a Suspense boundary (e.g., around or locally).

frontend/src/components/OnboardingSteps/OnboardingStep.tsx (2)

9-9: Unify import style

Use the alias path for consistency with other imports in this file.

-import { ServerCheck } from './ServerCheck';
+import { ServerCheck } from '@/components/OnboardingSteps/ServerCheck';

---

41-42: Confirm step list vs. progress count

SERVER_CHECK renders, but VISIBLE_STEPS excludes both SERVER_CHECK and UPDATE_STEP. If you show progress based on totalSteps, this may misreport progress when these steps run.

Consider computing totalSteps from the actual active flow or include these steps when applicable.

frontend/src/api/axiosConfig.ts (1)

13-20: Duped axios config — consider a factory

Both clients share identical config except baseURL. Reduce duplication and centralize headers/timeouts.

-export const syncApiClient = axios.create({
-  baseURL: SYNC_MICROSERVICE_URL,
-  timeout: 10000, // 10 seconds timeout
-  headers: {
-    'Content-Type': 'application/json',
-    Accept: 'application/json',
-  },
-});
+const makeApiClient = (baseURL: string) =>
+  axios.create({
+    baseURL,
+    timeout: 10000,
+    headers: { 'Content-Type': 'application/json', Accept: 'application/json' },
+  });
+
+export const syncApiClient = makeApiClient(SYNC_MICROSERVICE_URL);

Also confirm CORS/cookies needs; add withCredentials if required by the sync service.

frontend/src/api/api-functions/health.ts (1)

1-16: Add minimal error handling or document thrown errors

Calls will throw on non-2xx. If ServerCheck expects a boolean/shape, consider normalizing here; otherwise, ensure the caller has try/catch.

Example normalization:

-export const getMainBackendHealthStatus = async (): Promise<APIResponse> => {
-  const response = await apiClient.get<APIResponse>(healthEndpoints.healthCheck);
-  return response.data;
-};
+export const getMainBackendHealthStatus = async (): Promise<APIResponse> => {
+  try {
+    const { data } = await apiClient.get<APIResponse>(healthEndpoints.healthCheck);
+    return data;
+  } catch (e) {
+    // map to your APIResponse error shape if available
+    throw e;
+  }
+}

frontend/src/components/Dialog/InfoDialog.tsx (1)

66-70: Prevent dismiss via ESC/click-outside when close is hidden

If the intent is a truly non-dismissible dialog, also block onOpenChange when showCloseButton is false.

Add guards:

// around line 49-54
<Dialog
  open={isOpen}
  onOpenChange={(open) => {
    if (!open && showCloseButton === false) return; // ignore outside/Esc
    if (!open) handleClose();
  }}
>

frontend/src/pages/ComingSoon/ComingSoon.tsx (1)

1-47: Solid placeholder; minor a11y tweak

Mark decorative icons as aria-hidden to reduce noise for screen readers.

-              <Clock className="text-primary h-8 w-8" />
+              <Clock aria-hidden="true" className="text-primary h-8 w-8" />
...
-              <Sparkles className="h-5 w-5 text-yellow-500" />
+              <Sparkles aria-hidden="true" className="h-5 w-5 text-yellow-500" />

frontend/src/features/infoDialogSlice.ts (1)

25-30: Minor: streamline defaulting via payload destructuring.

Removes repeated action.payload.* and centralizes defaults.

-      state.title = action.payload.title;
-      state.message = action.payload.message;
-      state.variant = action.payload.variant || 'info';
-      state.showCloseButton = action.payload.showCloseButton ?? true;
+      const {
+        title,
+        message,
+        variant = 'info',
+        showCloseButton = true,
+      } = action.payload;
+      state.title = title;
+      state.message = message;
+      state.variant = variant;
+      state.showCloseButton = showCloseButton;

frontend/src/components/OnboardingSteps/ServerCheck.tsx (2)

23-27: Use unique React Query keys for health checks.

['clusters'] is generic and risks cache collisions with real cluster data. Prefer specific keys.

-  } = usePictoQuery({
-    queryKey: ['clusters'],
+  } = usePictoQuery({
+    queryKey: ['mainBackendHealth'],
     queryFn: getMainBackendHealthStatus,
@@
-  } = usePictoQuery({
-    queryKey: ['syncMicroservice'],
+  } = usePictoQuery({
+    queryKey: ['syncHealth'],
     queryFn: getSyncMicroserviceHealthStatus,

Also applies to: 33-37

---

38-56: Clear the scheduled exit timeout to avoid leaks/repeated exits.

If the component unmounts or states flap, the pending timeout should be cleared.

-  useEffect(() => {
+  useEffect(() => {
+    let exitTimer: number | undefined;
@@
-      setTimeout(() => {
-        exit(1);
-      }, 2000);
+      exitTimer = window.setTimeout(() => {
+        void exit(1);
+      }, 2000);
     }
@@
-  }, [
+    return () => {
+      if (exitTimer) {
+        clearTimeout(exitTimer);
+      }
+    };
+  }, [
     mainBackendSuccess,
     mainBackendLoading,
     mainBackendError,
     syncMicroserviceSuccess,
     syncMicroserviceLoading,
     syncMicroserviceError,
+    dispatch,
+    stepIndex,
   ]);

Also applies to: 61-68

frontend/src/pages/SettingsPage/Settings.tsx (3)

106-114: Disable controls while saving to prevent rapid re-submits.

Tie UI interactivity to mutation pending state.

   const {
-    mutate: updatePreferencesMutate,
-    isSuccess: updatePreferencesSuccess,
-    isError: updatePreferencesError,
+    mutate: updatePreferencesMutate,
+    isSuccess: updatePreferencesSuccess,
+    isError: updatePreferencesError,
+    isPending: updatePreferencesPending,
   } = usePictoMutation({
     mutationFn: updateUserPreferences,
   });

-                  <Button variant="outline" className="w-32 justify-between">
+                  <Button
+                    variant="outline"
+                    className="w-32 justify-between"
+                    disabled={updatePreferencesPending}
+                  >

                 <Switch
                   id="gpu-acceleration"
                   checked={userPreferences.GPU_Acceleration}
                   onCheckedChange={(checked) =>
                     handlePreferenceUpdate({
                       ...userPreferences,
                       GPU_Acceleration: checked,
                     })
                   }
+                  disabled={updatePreferencesPending}
                 />

Also applies to: 349-353, 406-416

---

123-126: Make updates atomic with functional setState to avoid stale closures.

Merges patches and ensures the mutation uses the latest state.

-  const handlePreferenceUpdate = (updatedPreferences: UserPreferencesData) => {
-    setUserPreferences(updatedPreferences);
-    updatePreferencesMutate(updatedPreferences);
-  };
+  const handlePreferenceUpdate = (patch: Partial<UserPreferencesData>) => {
+    setUserPreferences(prev => {
+      const next = { ...prev, ...patch };
+      updatePreferencesMutate(next);
+      return next;
+    });
+  };

-                    onClick={() =>
-                      handlePreferenceUpdate({
-                        ...userPreferences,
-                        YOLO_model_size: 'nano',
-                      })
-                    }
+                    onClick={() => handlePreferenceUpdate({ YOLO_model_size: 'nano' })}

-                    onClick={() =>
-                      handlePreferenceUpdate({
-                        ...userPreferences,
-                        YOLO_model_size: 'small',
-                      })
-                    }
+                    onClick={() => handlePreferenceUpdate({ YOLO_model_size: 'small' })}

-                    onClick={() =>
-                      handlePreferenceUpdate({
-                        ...userPreferences,
-                        YOLO_model_size: 'medium',
-                      })
-                    }
+                    onClick={() => handlePreferenceUpdate({ YOLO_model_size: 'medium' })}

-                  onCheckedChange={(checked) =>
-                    handlePreferenceUpdate({
-                      ...userPreferences,
-                      GPU_Acceleration: checked,
-                    })
-                  }
+                  onCheckedChange={(checked) =>
+                    handlePreferenceUpdate({ GPU_Acceleration: checked })
+                  }

Also applies to: 357-362, 367-372, 377-382, 409-414

---

479-479: Simplify boolean expression.

false || x is just x.

-        showCloseButton={false || !isDownloading}
+        showCloseButton={!isDownloading}

frontend/src/api/api-functions/user_preferences.ts (4)

6-22: DRY the repeated union and future‑proof sizes

Extract a reusable size type/constant and use Partial<UserPreferencesData> for the update request.

-export interface UserPreferencesData {
-  YOLO_model_size: 'nano' | 'small' | 'medium';
-  GPU_Acceleration: boolean;
-}
+export const YOLO_MODEL_SIZES = ['nano', 'small', 'medium'] as const;
+export type YoloModelSize = typeof YOLO_MODEL_SIZES[number];
+export interface UserPreferencesData {
+  YOLO_model_size: YoloModelSize;
+  GPU_Acceleration: boolean;
+}
@@
-export interface UpdateUserPreferencesRequest {
-  YOLO_model_size?: 'nano' | 'small' | 'medium';
-  GPU_Acceleration?: boolean;
-}
+export type UpdateUserPreferencesRequest = Partial<UserPreferencesData>;

Optional: If APIResponse supports generics, prefer APIResponse<UserPreferencesData> over extending and adding user_preferences manually.

---

6-9: Consider transport vs domain casing

Server-style keys (YOLO_model_size, GPU_Acceleration) are unconventional in TS UIs. Consider mapping to camelCase in the frontend domain model to isolate API wire format from UI types.

---

24-31: Support request cancellation

Expose an optional AbortSignal to prevent orphaned in-flight calls when navigating away.

-export const getUserPreferences =
-  async (): Promise<GetUserPreferencesResponse> => {
-    const response = await apiClient.get<GetUserPreferencesResponse>(
-      userPreferencesEndpoints.getUserPreferences,
-    );
-    return response.data;
-  };
+export const getUserPreferences =
+  async (options?: { signal?: AbortSignal }): Promise<GetUserPreferencesResponse> => {
+    const response = await apiClient.get<GetUserPreferencesResponse>(
+      userPreferencesEndpoints.getUserPreferences,
+      { signal: options?.signal },
+    );
+    return response.data;
+  };

---

33-41: PUT with a partial payload — confirm backend contract (else use PATCH)

You’re sending a partial but using PUT (often implies full replacement). Verify backend expects PUT+partial; otherwise switch to PATCH. Added cancellation support in either case.

 export const updateUserPreferences = async (
-  request: UpdateUserPreferencesRequest,
-): Promise<UpdateUserPreferencesResponse> => {
-  const response = await apiClient.put<UpdateUserPreferencesResponse>(
-    userPreferencesEndpoints.updateUserPreferences,
-    request,
-  );
+  request: UpdateUserPreferencesRequest,
+  options?: { signal?: AbortSignal },
+): Promise<UpdateUserPreferencesResponse> => {
+  const response = await apiClient.put<UpdateUserPreferencesResponse>(
+    userPreferencesEndpoints.updateUserPreferences,
+    request,
+    { signal: options?.signal },
+  );
   return response.data;
 };

If backend expects PATCH instead:

-  const response = await apiClient.put<UpdateUserPreferencesResponse>(
+  const response = await apiClient.patch<UpdateUserPreferencesResponse>(

Run to confirm server method/shape:

#!/bin/bash
set -euo pipefail

echo "Find endpoints and method for /user-preferences"
rg -n -C2 -S '/user-preferences' 

echo "PUT/PATCH route defs"
rg -n -C2 -P '@(app|router)\.(put|patch)\s*\(\s*["'\'']/user-preferences/?'

echo "Confirm response keys"
rg -n -C2 -S '\buser_preferences\b|\bYOLO_model_size\b|\bGPU_Acceleration\b'

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro